home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / samples / quad.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-12-15  |  10.6 KB  |  454 lines
  1. /*
  2.  * Copyright (c) 1991, 1992, 1993 Silicon Graphics, Inc.
  3.  *
  4.  * Permission to use, copy, modify, distribute, and sell this software and
  5.  * its documentation for any purpose is hereby granted without fee, provided
  6.  * that (i) the above copyright notices and this permission notice appear in
  7.  * all copies of the software and related documentation, and (ii) the name of
  8.  * Silicon Graphics may not be used in any advertising or
  9.  * publicity relating to the software without the specific, prior written
  10.  * permission of Silicon Graphics.
  11.  *
  12.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF
  13.  * ANY KIND,
  14.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  15.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  16.  *
  17.  * IN NO EVENT SHALL SILICON GRAPHICS BE LIABLE FOR
  18.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  19.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  20.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  21.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  22.  * OF THIS SOFTWARE.
  23.  */
  24.  
  25. #include <stdio.h>
  26. #include <string.h>
  27. #include <stdlib.h>
  28. #include <GL/glut.h>
  29.  
  30.  
  31. #define PI 3.141592654
  32. #define BLACK 0
  33. #define GRAY 128
  34. #define WHITE 255
  35. #define RD 0xA4,0x00,0x00,0xFF
  36. #define WT 0xFF,0xFF,0xFF,0xFF
  37. #define brickImageWidth 16
  38. #define brickImageHeight 16
  39.  
  40.  
  41. #include "loadppm.c"
  42.  
  43. GLenum rgb, doubleBuffer;
  44.  
  45. #include "tkmap.c"
  46.  
  47. float black[3] = {
  48.     0.0, 0.0, 0.0
  49. };
  50. float blue[3] =  {
  51.     0.0, 0.0, 1.0
  52. };
  53. float gray[3] =  {
  54.     0.5, 0.5, 0.5
  55. };
  56. float white[3] = {
  57.     1.0, 1.0, 1.0
  58. };
  59.  
  60. GLenum doDither = GL_TRUE;
  61. GLenum shade = GL_TRUE;
  62. GLenum texture = GL_TRUE;
  63.  
  64. float xRotation = 30.0, yRotation = 30.0, zRotation = 0.0;
  65. GLint radius1, radius2;
  66. GLdouble angle1, angle2;
  67. GLint slices, stacks;
  68. GLint height;
  69. GLint orientation = GLU_OUTSIDE;
  70. GLint whichQuadric=0;
  71. GLUquadricObj *quadObj;
  72.  
  73. GLubyte brickImage[4*brickImageWidth*brickImageHeight] = {
  74.     RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  75.     RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  76.     RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  77.     RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD,
  78.     WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT,
  79.     RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  80.     RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  81.     RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  82.     RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD, RD,
  83.     WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT,
  84.     RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  85.     RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  86.     RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  87.     RD, RD, RD, RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD,
  88.     WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT, WT,
  89.     RD, RD, RD, RD, WT, RD, RD, RD, RD, RD, RD, RD, RD, RD, WT, RD
  90. };
  91. char *texFileName = 0;
  92.  
  93.  
  94. static void CALLBACK ErrorHandler(GLenum which)
  95. {
  96.  
  97.     fprintf(stderr, "Quad Error: %s\n", gluErrorString(which));
  98. }
  99.  
  100. static void Init(void)
  101. {
  102.     static GLint colorIndexes[3] = {0, 200, 255};
  103.     static float ambient[] = {0.1, 0.1, 0.1, 1.0};
  104.     static float diffuse[] = {0.5, 1.0, 1.0, 1.0};
  105.     static float position[] = {90.0, 90.0, 150.0, 0.0};
  106.     static float front_mat_shininess[] = {30.0};
  107.     static float front_mat_specular[] = {0.2, 0.2, 0.2, 1.0};
  108.     static float front_mat_diffuse[] = {0.5, 0.28, 0.38, 1.0};
  109.     static float back_mat_shininess[] = {50.0};
  110.     static float back_mat_specular[] = {0.5, 0.5, 0.2, 1.0};
  111.     static float back_mat_diffuse[] = {1.0, 1.0, 0.2, 1.0};
  112.     static float lmodel_ambient[] = {1.0, 1.0, 1.0, 1.0};
  113.     static float lmodel_twoside[] = {(GLint)GL_TRUE};
  114.     static float decal[] = {(GLint)GL_DECAL};
  115.     static float repeat[] = {(GLint)GL_REPEAT};
  116.     static float nearest[] = {(GLint)GL_NEAREST};
  117.     static PPMImage *image;
  118.  
  119.     if (!rgb) {
  120.     SetGreyRamp();
  121.     }
  122.     glClearColor(0.0, 0.0, 0.0, 0.0);
  123.     
  124.     glEnable(GL_DEPTH_TEST);
  125.  
  126.     glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
  127.     glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
  128.     glLightfv(GL_LIGHT0, GL_POSITION, position);
  129.     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
  130.     glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
  131.     glEnable(GL_LIGHTING);
  132.     glEnable(GL_LIGHT0);
  133.  
  134.     glMaterialfv(GL_FRONT, GL_SHININESS, front_mat_shininess);
  135.     glMaterialfv(GL_FRONT, GL_SPECULAR, front_mat_specular);
  136.     glMaterialfv(GL_FRONT, GL_DIFFUSE, front_mat_diffuse);
  137.     glMaterialfv(GL_BACK, GL_SHININESS, back_mat_shininess);
  138.     glMaterialfv(GL_BACK, GL_SPECULAR, back_mat_specular);
  139.     glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse);
  140.     if (!rgb) {
  141.     glMaterialiv( GL_FRONT_AND_BACK, GL_COLOR_INDEXES, colorIndexes);
  142.     }
  143.  
  144.     glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, decal);
  145.     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, repeat);
  146.     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, repeat);
  147.     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, nearest);
  148.     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, nearest);
  149.     if (texFileName) {
  150.     image = LoadPPM(texFileName);
  151.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  152.     gluBuild2DMipmaps(GL_TEXTURE_2D, 3, image->sizeX, image->sizeY,
  153.               GL_RGB, GL_UNSIGNED_BYTE, image->data);
  154.     } else {
  155.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  156.     glTexImage2D(GL_TEXTURE_2D, 0, 4, brickImageWidth, brickImageHeight,
  157.              0, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *)brickImage);
  158.     }
  159.  
  160.     quadObj = gluNewQuadric();
  161. #ifndef __STORM__
  162.     gluQuadricCallback(quadObj, GLU_ERROR, ErrorHandler);
  163. #else
  164.     gluQuadricCallback(quadObj, GLU_ERROR, (void(CALLBACK *)())ErrorHandler);
  165. #endif
  166.  
  167.     radius1 = 10;
  168.     radius2 = 5;
  169.     angle1 = 90;
  170.     angle2 = 180;
  171.     slices = 16;
  172.     stacks = 10;
  173.     height = 20;
  174. }
  175.  
  176. static void Reshape(int width, int height)
  177. {
  178.  
  179.     glViewport(0, 0, (GLint)width, (GLint)height);
  180.  
  181.     glMatrixMode(GL_PROJECTION);
  182.     glLoadIdentity();
  183.     glFrustum(-1, 1, -1, 1, 1, 10);
  184.     gluLookAt(2, 2, 2, 0, 0, 0, 0, 0, 1);
  185.     glMatrixMode(GL_MODELVIEW);
  186. }
  187.  
  188. static void Key2(int key, int x, int y)
  189. {
  190.  
  191.     switch (key) {
  192.       case GLUT_KEY_LEFT:
  193.     yRotation += 5;
  194.     break;
  195.       case GLUT_KEY_RIGHT:
  196.     yRotation -= 5;
  197.     break;
  198.       case GLUT_KEY_UP:
  199.     xRotation += 5;
  200.     break;
  201.       case GLUT_KEY_DOWN:
  202.     xRotation -= 5;
  203.     break;
  204.       default:
  205.     return;
  206.     }
  207.  
  208.     glutPostRedisplay();
  209. }
  210.  
  211. static void Key(unsigned char key, int x, int y)
  212. {
  213.  
  214.     switch (key) {
  215.       case 27:
  216.     exit(1);
  217.  
  218.       case 'X':
  219.     zRotation += 5;
  220.     break;
  221.       case 'x':
  222.     zRotation -= 5;
  223.     break;
  224.  
  225.       case '1':
  226.     gluQuadricDrawStyle(quadObj, GLU_FILL);
  227.     break;
  228.       case '2':
  229.     gluQuadricDrawStyle(quadObj, GLU_POINT);
  230.     break;
  231.       case '3':
  232.     gluQuadricDrawStyle(quadObj, GLU_LINE);
  233.     break;
  234.       case '4':
  235.     gluQuadricDrawStyle(quadObj, GLU_SILHOUETTE);
  236.     break;
  237.  
  238.       case '0':
  239.     shade = !shade;
  240.     if (shade) {
  241.         glShadeModel(GL_SMOOTH);
  242.         gluQuadricNormals(quadObj, GLU_SMOOTH);
  243.     } else {
  244.         glShadeModel(GL_FLAT);
  245.         gluQuadricNormals(quadObj, GLU_FLAT);
  246.     }
  247.     break;
  248.  
  249.       case 'A':
  250.     stacks++;
  251.     break;
  252.       case 'a':
  253.     stacks--;
  254.     break;
  255.     
  256.       case 'S':
  257.     slices++;
  258.     break;
  259.       case 's':
  260.     slices--;
  261.     break;
  262.  
  263.       case 'd':
  264.     switch(orientation) {
  265.       case GLU_OUTSIDE:
  266.         orientation = GLU_INSIDE;
  267.         break;
  268.       case GLU_INSIDE:
  269.       default:
  270.         orientation = GLU_OUTSIDE;
  271.         break;
  272.     }
  273.     gluQuadricOrientation(quadObj, orientation);
  274.     break;
  275.  
  276.       case 'f':
  277.     whichQuadric = (whichQuadric + 1) % 4;
  278.     break;
  279.  
  280.       case 'G':
  281.     radius1 += 1;
  282.     break;
  283.       case 'g':
  284.     radius1 -= 1;
  285.     break;
  286.  
  287.       case 'J':
  288.     radius2 += 1;
  289.     break;
  290.       case 'j':
  291.     radius2 -= 1;
  292.     break;
  293.  
  294.       case 'H':
  295.     height += 2;
  296.     break;
  297.       case 'h':
  298.     height -= 2;
  299.     break;
  300.  
  301.       case 'K':
  302.     angle1 += 5;
  303.     break;
  304.       case 'k':
  305.     angle1 -= 5;
  306.     break;
  307.  
  308.       case 'L':
  309.     angle2 += 5;
  310.     break;
  311.       case 'l':
  312.     angle2 -= 5;
  313.     break;
  314.  
  315.       case 'z':
  316.     texture = !texture;
  317.     if (texture) {
  318.         gluQuadricTexture(quadObj, GL_TRUE);
  319.         glEnable(GL_TEXTURE_2D);
  320.     } else {
  321.         gluQuadricTexture(quadObj, GL_FALSE);
  322.         glDisable(GL_TEXTURE_2D);
  323.     }
  324.     break;
  325.  
  326.       case 'q':
  327.     glDisable(GL_CULL_FACE);
  328.     break;
  329.       case 'w':
  330.     glEnable(GL_CULL_FACE);
  331.     glCullFace(GL_FRONT);
  332.     break;
  333.       case 'e':
  334.     glEnable(GL_CULL_FACE);
  335.     glCullFace(GL_BACK);
  336.     break;
  337.  
  338.       case 'r':
  339.     glFrontFace(GL_CW);
  340.     break;
  341.       case 't': 
  342.     glFrontFace(GL_CCW);
  343.     break;
  344.  
  345.       case 'y':
  346.     doDither = !doDither;
  347.     (doDither) ? glEnable(GL_DITHER) : glDisable(GL_DITHER);
  348.     break;
  349.       default:
  350.     return;
  351.     }
  352.  
  353.     glutPostRedisplay();
  354. }
  355.  
  356. static void Draw(void)
  357. {
  358.  
  359.     glLoadIdentity();
  360.     glRotatef(xRotation, 1, 0, 0);
  361.     glRotatef(yRotation, 0, 1, 0);
  362.     glRotatef(zRotation, 0, 0, 1);
  363.  
  364.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  365.  
  366.     glColor3f(1.0, 1.0, 1.0);
  367.     switch (whichQuadric) {
  368.       case 0:
  369.     glTranslatef(0, 0, -height/20.0);
  370.     gluCylinder(quadObj, radius1/10.0, radius2/10.0, height/10.0, 
  371.             slices, stacks);
  372.     break;
  373.       case 1:
  374.     gluSphere(quadObj, radius1/10.0, slices, stacks);
  375.     break;
  376.       case 2:
  377.     gluPartialDisk(quadObj, radius2/10.0, radius1/10.0, slices, 
  378.                stacks, angle1, angle2);
  379.     break;
  380.       case 3:
  381.     gluDisk(quadObj, radius2/10.0, radius1/10.0, slices, stacks);
  382.     break;
  383.     }
  384.  
  385.     glFlush();
  386.  
  387.     if (doubleBuffer) {
  388.     glutSwapBuffers();
  389.     }
  390. }
  391.  
  392. static GLenum Args(int argc, char **argv)
  393. {
  394.     GLint i;
  395.  
  396.     rgb = GL_TRUE;
  397.     doubleBuffer = GL_FALSE;
  398.  
  399.     for (i = 1; i < argc; i++) {
  400.     if (strcmp(argv[i], "-ci") == 0) {
  401.         rgb = GL_FALSE;
  402.     } else if (strcmp(argv[i], "-rgb") == 0) {
  403.         rgb = GL_TRUE;
  404.     } else if (strcmp(argv[i], "-sb") == 0) {
  405.         doubleBuffer = GL_FALSE;
  406.     } else if (strcmp(argv[i], "-db") == 0) {
  407.         doubleBuffer = GL_TRUE;
  408.     } else if (strcmp(argv[i], "-f") == 0) {
  409.         if (i+1 >= argc || argv[i+1][0] == '-') {
  410.         printf("-f (No file name).\n");
  411.         return GL_FALSE;
  412.         } else {
  413.         texFileName = argv[++i];
  414.         }
  415.     } else {
  416.         printf("%s (Bad option).\n", argv[i]);
  417.         return GL_FALSE;
  418.     }
  419.     }
  420.     return GL_TRUE;
  421. }
  422.  
  423. void main(int argc, char **argv)
  424. {
  425.     GLenum type;
  426.  
  427.     glutInit(&argc, argv);
  428.  
  429.     if (Args(argc, argv) == GL_FALSE) {
  430.     exit(1);
  431.     }
  432.  
  433.     glutInitWindowPosition(0, 0); glutInitWindowSize( 300, 300);
  434.  
  435.     type = GLUT_DEPTH;
  436.     type |= (rgb) ? GLUT_RGB : GLUT_INDEX;
  437.     type |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE;
  438.     glutInitDisplayMode(type);
  439.  
  440.     if (glutCreateWindow("Quad Test") == GL_FALSE) {
  441.     exit(1);
  442.     }
  443.  
  444.     InitMap();
  445.  
  446.     Init();
  447.  
  448.     glutReshapeFunc(Reshape);
  449.     glutKeyboardFunc(Key);
  450.     glutSpecialFunc(Key2);
  451.     glutDisplayFunc(Draw);
  452.     glutMainLoop();
  453. }
  454.